#ifndef PLATEAURISQ_H
#define PLATEAURISQ_H

#include <QtCore>

class Pion;
class Etat;
class Continent;
class Joueur;
class Frontiere;
class Missions;

class PionGraphics;
class EtatGraphics;

/**
 * @author LOPEZ CARONT AFFOREAU PERIGNON
 * @brief Ã‰numeration des différents status du plateau
 * (non utilisé)
 */
typedef enum _PlateauStatus {
    RIEN_FAIRE,
    EDIT_MODE,
    ASSIGNATION
}PlateauStatus;

/**
 * @brief Représente le plateau du jeu RisQ
 * Stock les états, les continents et les joueurs
 *
 */
class PlateauRisQ : public QObject
{
    Q_OBJECT

public:
    PlateauRisQ();

    /**
     * @brief Charge un plateau en fonction du nom
     *
     * @param name
     * @return bool true si réussi sinon false erreur de fichier
     */
    bool chargerPlateau(QString nom);

    void creerObjectifs();
    void appelleRenforts();
    bool est_au_meme_joueur(Continent* c, Joueur* j);
    int nbr_etats_acquis( Joueur* j);
    bool taille_min_armee( Joueur* j, int nb_etats_min, int taille_min_voulue);
    int taille_max_armee( Joueur* j);


    /**
     * @brief Assigne les états au joueurs du plateau
     *
     */
    void assigneEtat();

    /**
     * @brief Calcul et met à jour les stats pour un joueur
     *
     * @param j
     */
    void updateJoueurStatus(Joueur *j);

    /**
     * @brief S'occupe de charger le XML représentant le plateau
     * et de crée les états, continents et frontières
     *
     * @param filename
     */
    int chargerXml(QString filename);

    /**
     * @brief Reset le plateau de jeu, cad enlève
     * tous les pions et set les états à null
     */
    void reset();

    const QHash<int, Etat*> etats(){ return etatsList; }
    const QList<Continent *> continents(){ return continentsList; }
    const QList<Joueur*> joueurs(){ return joueursList; }

    void addJoueur(Joueur *j){
        joueursList.append(j);
        emit nouveauJoueur(j);
    }

    void removeJoueur(Joueur *j){
        joueursList.removeOne(j);
        emit supprimerJoueur(j);
    }

    void setStatus(PlateauStatus s){
        status = s;
    }

    PlateauStatus getStatus(){
        return status;
    }

    void setMoi(Joueur *j){
        moi = j;
    }

    Joueur * getMoi(){
        return moi;
    }

    void setPlateauNom(QString nom){
        nomPlateau = nom;
    }

    QString getPlateauNom(){
        return nomPlateau;
    }

    QString getRessourcesPath(){
        return ressourcesPath;
    }

    // bon vu que les fonctions sont déjà déclarées ET définies dans le .h je continue

    int getJoueur_en_cours()
    {
        return Joueur_en_cours ;
    }

    void setJoueur_en_cours(int id_joueur)
    {
        Joueur_en_cours = id_joueur ;
    }


    bool getplacement_Initial()
    {
        return placement_Initial ;
    }

    void setplacement_Initial(bool pla)
    {
        placement_Initial = pla;
    }


    bool getjoueur_changed()
    {
        return joueur_changed;
    }

    void setjoueur_changed(bool cha)
    {
        joueur_changed = cha ;
    }


    bool getplacement_renforts()
    {

        return placement_renforts;

    }

    void setplacement_renforts(bool st)
    {
        placement_renforts = st ;
    }


    bool getattaques()
    {
        return attaques;
    }

    void setattaques(bool at)
    {
        attaques = at ;
    }


    bool getdeplacement_troupes()
    {
        return deplacement_troupes ;
    }

    void setdeplacement_troupes(bool dep)
    {
        deplacement_troupes = dep ;
    }

    int getJoueurs_ayant_restant_nul()
    {
        return Joueurs_ayant_restant_nul;
    }

    void setJoueurs_ayant_restant_nul(int nou)
    {
        Joueurs_ayant_restant_nul = nou;
    }

    int getnbMaxJoueurs()
    {
        return nbMaxJoueurs;
    }

    void setnbMaxJoueurs(int nb)
    {
        nbMaxJoueurs = nb ;
    }

    QString getEnvInitialisation()
    {
        return envoiInitialisation;
    }

    void addEnvInitialisation(QString ajout)
    {
        envoiInitialisation.append(ajout);
    }

    Missions* getObjectif(int i)
    {
        return objectifs.at(i);
    }

    int getEtat_attaquant()
    {
       return etat_attaquant;
    }

    void setEtat_attaquant(int eA)
    {
        etat_attaquant = eA;
    }

    int getEtat_cible()
    {
       return etat_cible;
    }

    void setEtat_cible(int eC)
    {
        etat_cible = eC;
    }

    /**
     * @brief Simule une escarmouche
     * de l'état attaquant vers l'état cible
     *
     * @param idAttaquant idCible
     */
    void attaque(int idAttaquant, int idCible);

    void placementInitial(Etat* etat);

    void placementRenfort(Etat* etat);


public slots:


signals:
    /**
     * @brief Emit lors de l'ajout d'un pion
     *
     * @param p
     */
    void nouveauPion(Pion *p);

    /**
     * @brief Emit lors de la suppression d'un pion
     *
     * @param p
     */
    void supprimerPion(Pion *p);

    /**
     * @brief Emit lors de l'ajout d'un état
     *
     * @param e
     */
    void nouveauEtat(Etat *e);

    /**
     * @brief Emit lors de l'ajout d'une frontière
     *
     * @param e
     */
    void nouvelleFrontiere(Frontiere *e);

    void nouveauJoueur(Joueur *j);

    void supprimerJoueur(Joueur *j);

    void ChangeStatut();

    void ChangeJoueur(QString data);


protected:
    QString ressourcesPath; /**< Path ou sont stocké les plateaux de jeu */
    QString nomPlateau; /**< Nom du plateau chargé */
    Joueur *moi; /**< Représente le joueur */

    PlateauStatus status; /**< Pour définir plusieurs modes, pas encore utilisé  */

    QHash<int, Etat*> etatsList;
    QList<Continent *> continentsList;
    QList<Joueur*> joueursList;
    bool placement_Initial ;
    bool joueur_changed;
    bool placement_renforts ;
    bool attaques ;
    bool deplacement_troupes ;
    int Joueur_en_cours ;
    int Joueurs_ayant_restant_nul;    
    int etat_attaquant;
    int etat_cible;
    int nbMaxJoueurs;
    QList<Missions*> objectifs;
    QString envoiInitialisation ; // utilisé seulement sur le plateau du serveur.


};

#endif // PLATEAURISQ_H
